/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2021-2022. All rights reserved.
 *
 */

/**
 * 获取两个集合的交集
 *
 * @param arr1 集合1
 * @param arr2 集合2
 */
export function getIntersection<T>(arr1: T[], arr2: T[]) {
  return arr1.filter(function (val) {
    return arr2.indexOf(val) > -1;
  });
}

/**
 * 根据name获取一个以某个key为唯一标识的集合中的元素
 *
 * @param arr1 数组
 * @param elementName 元素name
 * @param uniqueKey 用于判定唯一标识的key
 */
export function getElementFromArr<T extends Record<string, unknown>>(arr1: T[] | undefined, elementName: string, uniqueKey = 'name'): T | undefined {
  if (arr1 === undefined) {
    return undefined;
  }
  for (const value of arr1) {
    if (value[uniqueKey] === elementName) {
      return value;
    }
  }
  return undefined;
}

/**
 * 找出数组内重复元素
 *
 * @param list list
 * @return 重复元素列表
 */
export function findDuplicateElement<T>(list: T[]): T[] {
  const arr: Set<T> = new Set();
  const listSet: Set<T> = new Set();
  list.forEach((element) => {
    if (listSet.has(element)) {
      arr.add(element);
    } else {
      listSet.add(element);
    }
  });
  return [...arr];
}

/**
 * 判断集合是否一致(有序)
 *
 * @param list1 list1
 * @param list2 list2
 */
export function checkArrayIsSame(list1: string[], list2: string[]): boolean {
  if (list1.length === list2.length) {
    for (let i = 0; i < list1.length; i++) {
      if (list1[i] !== list2[i]) {
        return false;
      }
    }
    return true;
  } else {
    return false;
  }
}

/**
 * 判断两个集合元素是否一致(无序）
 *
 * @param list1 list1
 * @param list2 list2
 */
export function checkArrayElementIsSame(list1: string[], list2: string[]): boolean {
  if (list1.length === list2.length) {
    return JSON.stringify(list1.sort()) === JSON.stringify(list2.sort());
  }
  return false;
}

/**
 * 判断目标数组是否为原始数组的子集
 *
 * @param originArr 原始数组
 * @param targetArr 目标数组
 */
export function isSubset(originArr: any[], targetArr: any[]): boolean {
  return targetArr.every((target) => {
    return originArr.includes(target);
  });
}

/**
 * 获取目标数组子集在原始数组集合中的补集
 *
 * @param originArr 原始数组
 * @param targetArr 目标数组
 */
export function complementarySet(originArr: any[], targetArr: any[]): any[] {
  return originArr.filter((target) => {
    return !targetArr.includes(target);
  });
}

/**
 * 判断两个集合是否存在交集
 *
 * @param arr1 arr1
 * @param arr2 arr2
 */
export function checkIntersection(arr1: any[] | undefined, arr2: any[] | undefined): boolean {
  if (!arr1 || !arr2) {
    return false;
  }
  return arr1.filter((val) => arr2.includes(val)).length > 0;
}

/**
 * 获取两个数组的并集
 * @param arr1
 * @param arr2
 */
export function getUnionSet(arr1: any[] = [], arr2: any[] = []): any[] {
  return Array.from(new Set([...arr1, ...arr2]));
}

/**
 * 获取两个集合的交集
 * @param set1
 * @param set2
 */
export function getIntersectedSet(set1: Set<string> | undefined, set2: Set<string> | undefined): Set<string> {
  if (!set1 || !set2) {
    return new Set<string>();
  }

  const intersectedList = Array.from(set1).filter((value) => {
    return set2.has(value);
  });
  return new Set(intersectedList);
}
